Mencari Akar Persamaan pada Persamaan Non Linear

Pencarian akar pada persamaan dapat dilakukan dengan pendekatan metode numerik, yaitu dengan metode berikut:

  1. Metode Bisection
  2. Metode Regula Falsi
  3. Metode Newton Rapson
  4. Motode Secant

Metode - metode tersebut dapat di manfaatkan untuk mencari akar dari persamaan non-linear. berikut adalah perhitungan dan implementasi pada bahasa pemrograman python dari algoritma metode numerik tersebut.

Metode Bisection

Metode biseksi ini membagi range menjadi 2 bagian, dari dua bagian ini dipilih bagian mana yang mengandung akar sedangkan bagian yang tidak mengandung akar akan dibuang. Hal ini dilakukan berulang-ulang hingga diperoleh suatu akar persamaan.

Algortima Pada Motode Bisection

  1. Definisikan fungsi $ f(x) $ yang akan dicari akarnya

  2. Tentukan nilai $ a $ dan $ b $

  3. Tentukan toleransi $ \epsilon $ dan iterasi maksimum $ N $

  4. Hitung $ f(a) $ dan $ f(b) $

  5. Jika $ f(a).f(b)>0 $ maka proses dihentikan karena tidak ada akar, bila tidak maka dilanjutkan

  6. Hitung $ x = (a+b)/2 $

  7. Hitung $ f(x) $

  8. Bila$ f(x).f(a)<0 $ maka $ b = x $ dan $ f(b)=f(x) $, bila tidak maka $ a=x $ dan $ f(a)=f(x) $

  9. Jika $ |b-a| < \epsilon $ atau iterasi telah mencapai iterasi maks maka proses dihentikan dan didapatkan akar $ x $, bila tidak, ulangi langkah 6

Perhitungan dalam Metode Bisection

  1. Pada Langkah Awal Mendifinisikan sebuah fungsi f(x), dimana f(x) yang akan digunakan adalah : $ f(x) = x^2 - 5x +6 $
  2. Langkah kedua menentukan Nilai a dan b, mengambil nilai batas awal $ (a) = 1 $ dan nilai batas bawahnya $ (b) = 2.4 $
  3. Langkah ketiga menentukan toleransi tingkat error dan iterasi maksimum (N), pada langkah ini tolerasi tingkat error yang akan digunakan =0,0001 dan iterasi maksimum yang digunakan =100
  4. Menghitung f(a) dan f(b), menghitung f(a) bisa kita gunakan pada fungsi f(x) pada langkah pertama.Dimana $ f(a)=1^2-5(1)+6=2$ dan $f(b)=(2.4)^2-5(2.4)+6=-0.2400000000000002 $
  5. Mengecek dengan kondisi ketika $ f(a).f(b)>0 $ maka proses itu akan diberhentikan, bila f(a).f(b)<0 maka akan lanjut ke proses berikutnya. Dimana ketika f(a) yang didapatkan = 2 dan f(b) = -0.2400000000000002 maka $ f(a).f(b) = 2 x -0.2400000000000002 = -0.4800000000000004 $ maka sudah dapat diketahui f(a).f(b) < 0
  6. Pada langkah ini menghitung $ x = (a+b)/2 $, dimana a =1 dan b = 2.4 maka $ x = (1+2.4)/2 = 1.7 $
  7. Setelah mendapatkan nilai $ x $ maka menghitung nilai f(x)nya dengan$ x = 1.7$ maka $f(1.7)= (1.7)^2 -5(1.7)+6 = 0.3899999999999997 $, maka didapatkan f(x) = 0.3899999999999997
  8. Melakukan pengecekan bila f(x).f(a)<0 maka b = x dan f(b)=f(x), tapi ketika f(x),f(a) tidak < dari 0 maka a =x dan f(a) = f(x) , dimana f(x) = 0.3899999999999997 dan $f(a) = 2 $ maka $f(x).f(a) = 0.7799999999999994 $ tidak < dari 0 maka a = x, jadi $a = 1,7 dan f(a) = 0.3899999999999997 $
  9. Maka Langkah berikutnya mengecek jika |b-a|<e atau Iterasi sudah mencapai iterasi maksimum maka proses dihentikan dan mendapatkan akar yang dicari. Dengan mengecek hasil dari |b-a|<e maka |b-a| =| 2.4 - 1.7|=0.7dapat diketahui bahwa |b-a| tidak < dari e maka terus melakukan iterasi sampai dengan iterasi maksimum

Implementasi Algoritma Metode Bisection Dengan Python

Berikut merupakan hasil implementasi metode bisection untuk mencari akar dari persamaan $ x^2 - 5x + 6 $ dengan batas error maksimal 0.001 .

error = 0.001
a = 0
b = 1

def f(x):
    return x**2 - 5*x + 6

def bisection(a,b):
    iteration = True
    while iteration :
        if f(a)*f(b) < 0:
            while iteration:
                x = (a+b)/2
                if f(a)*f(x) < 0:
                    b = x
                elif f(x)*f(b) < 0:
                    a = x
                if abs(a-b) < error:
                    return x
                    iteration=False
        else:
            b += 0.1

    print('x =', x)

bisection(a,b)

Dalam program tersebut di deklarasikan nilai a = 0 dan b = 1, dalam program tersebut akan mancari nilai b dengan sendirinya, dengan menambah b dengan 0.1

error = 0.001
a = 0
b = 1

Kemudian membuat persamaan yang di deklarasikan pada fungsi f(x).

def f(x):
    return x**2 - 5*x + 6

Selanjutnya merupakan program utama untuk mencari nilai x dari persamaan yang telah di deklarasikan. program akan berjalan dengan algoritma sebagaimana semestinya dalam metode bisection. saat nilai f(a)f(b) tidak kurang dari 0, maka akan mencarikan nilai b sampai kurang dari 0.

def bisection(a,b):
    iteration = True
    while iteration :
        if f(a)*f(b) < 0:
            while iteration:
                x = (a+b)/2
                if f(a)*f(x) < 0:
                    b = x
                elif f(x)*f(b) < 0:
                    a = x
                if abs(a-b) < error:
                    return x
                    iteration=False
        else:
            b += 0.1

Saat program tersebut di jalankan maka menghasilkan output seperti berikut dengan nilai x yang di dapat yaitu : 2.000024414062501.

x = 1.0500000000000005
x = 1.5750000000000006
x = 1.8375000000000008
x = 1.9687500000000009
x = 2.0343750000000007
x = 2.001562500000001
x = 1.9851562500000008
x = 1.9933593750000007
x = 1.9974609375000008
x = 1.9995117187500009
x = 2.000537109375001
x = 2.000024414062501
akar persamaan(x) =  2.000024414062501

Metode Regula Falsi

Metode ini adalah metode tertua untuk menemukan akar sebenarnya dari persamaan f (x) = 0. Ia juga dikenal sebagai metode akor atau metode interpolasi linier. Seperti metode pembagian dua bagian, posisi yang salah satu metodenya dimulai dengan dua titik a_0dan b_0 sedemikian rupa sehingga f (a_0) dan f(b_0) memiliki tanda-tanda yang berlawanan, yang menyiratkan oleh teorema nilai menengah bahwa fungsi f memiliki akar dalam interval [a_0, b_0], dengan asumsi kesinambungan dari fungsi f.

Metode pencarian akar persamaan dengan memanfaatkan kemiringan dan selisih tinggi dari dua titik batas range. Dua titik a dan b pada fungsi f(x) digunakan untuk mengestimasi posisi c dari akar interpolasi linier. Dikenal dengan metode False Position. Metode ini juga merupakan penyempurnan dari metode bisection.

Algortima Pada Motode Regula-Falsi

1.Definisikan fungsi $ f(x) $ yang akan dicari akarnya

2.Masukkan interval [a,b] dimana akar berada, atau bisa dengan menententukan nilai a dan b

3.Tentukan toleransi $ \epsilon $ dan iterasi maksimum N

4.Hitung $ f(a) $ dan $ f(b) $

5.Mengecek nilai f(a).f(b) <0 bila tidak maka proses nilai $ f(a).f(b)>0 $, akan memberhentikan proses perhitungan (program)

6.Mengkalkulasi x = {(a|f(b)|+b|f(a)|) \over |f(a)| +|f(b)|}

7.Jika $ f(a).f(x)<0 $ maka $ b = x $, ketika tidak jika $ f(x)f(b)<0 $ maka $ a = x $

8.Jika $ |b-a|< \epsilon $ , $ \epsilon $ menjadi akurasi yang ditentukan. Lalu lanjutkan ke Langkah 9 yang lain Langkah 4

9.Cetak nilai $ x $ yang dibutuhkan akar

Perhitugan dalam Metode Regula Falsi

  1. Pada Langkah Awal Mendifinisikan sebuah fungsi f(x), dimana f(x) yang akan digunakan adalah : f(x) = x^2 - 5x +6

  2. Langkah kedua menentukan Nilai a dan b, mengambil nilai batas awal (a) = 1 dan nilai batas bawahnya (b) = 2.4 . Maka dapat kita ketahui interval [a,b]= [1,2.4]

  3. Langkah ketiga menentukan toleransi tingkat error dan iterasi maksimum (N), pada langkah ini tolerasi tingkat error yang akan digunakan =0,0001 dan iterasi maksimum yang digunakan =50

  4. Menghitung f(a) dan f(b), menghitung f(a) bisa kita gunakan pada fungsi f(x) pada langkah pertama.Dimana f(a)=1^2-5(1)+6=2 dan f(b)=(2.4)^2-5(2.4)+6=-0.2400000000000002

  5. Mengecek dengan kondisi ketika $ f(a).f(b)>0$ maka proses itu akan diberhentikan, bila f(a).f(b)<0 maka akan lanjut ke proses berikutnya. Dimana ketika f(a) yang didapatkan = 2 dan f(b) = -0.2400000000000002 maka $ f(a).f(b) $= 2 x -0.2400000000000002 = -0.4800000000000004 maka sudah dapat diketahui f(a).f(b) < 0

  6. Mengkalkulus x = {(a|f(b)|+b|f(a)|) \over |f(a)| +|f(b|}, maka $$ x = {(1|-0.2400000000000002|+2.4|2|) \over |2| +|-0.2400000000000002|} \\ x = {1.2400000000000002 + 4.8 \over 2+0.2400000000000002} \\ x = {6.04 \over 2.24 } \\ x = 2.696428571428571 $$

  7. Pada langkah ini mengecek apakah $ f(a).f(x)<0$ maka b = x, ketika tidak jika f(x)f(b)<0 maka a = x. pertama harus menghitung f(x)nya dimana x nya = 2.696428571428571, maka $$ f(x)= x^2 -5x+6, \quad dimana (x)nya = 2.69642857142857 \\ f(x) = (2.69642857142857)^2-5(2.69642857142857)+6 \\ f(x) = 7.270727040816318 - 13.482142857142856+6 \\ f(x) = -0.2114158163265376 $$ Mengecek apakah f(a).f(x)<0, dimana f(a)=2, dan f(x)=-0.2114158163265376, maka $$ f(a).f(x)= 2 \quad X -0.2114158163265376 = -0.4228316326530752 $$ Dapat diketahui bahwa f(a).f(x)<0 maka set b = x, b = 2.696428571428571

  8. Mengecek |b-a|< ε, ε menjadi akurasi yang ditentukan. Lalu lanjutkan ke Langkah berikutnya yang lain Langkah 4 , maka melakukan pengecekan $$ |b-a|= 2.696428571428571 -2 = 0.6964285714285712 \\ |b-a| = 0.6964285714285712 \quad tidak < 0 , maka mengulang \quad ke langkah \quad ke 4 $$ Akan terus melakukan proses iterasi sampai |b-a|<e ketika proses berhasil maka lanjut ke langkah 9

  9. Mencetak nilai x , itu lah hasil dari nilai akar yang diperoleh

Implementasi Algoritma Metode Regula-Falsi Dengan Python

Pada Implementasi Algoritma Metode Regulasi-Falsi ini, Pada Langkah pertama ini membuat fungsi f(x) untuk bisa langsung memudahkan dalam perhitungan

def f(x):
    return x**2 - 5*x + 6

Pada Langkah Berikutnya membuat variabel kosong seperti variabel a dan b, serta error yang akan digunakan

error = 0.0001
a = 1
b = 2.4

Langkah Selanjutnya membuat fungsi , def Regulasi_falsi untuk bisa langsung mengkalkulasi hasil perhitungan pada fungsi yang digunakan diatas dan , memberikan suatu iterasi (looping) ketika ada kondisi yang sudah terpenuhi

def regula_falsi(a,b):
    i=0
    max_iter = 50
    iteration = True
    while iteration and i < max_iter:
        if f(a)*f(b) < 0:
            x = (a*abs(f(b)) + b*abs(f(a))) / (abs(f(a)) + abs(f(b)))
            if f(a)*f(x) < 0:
                b = x
                print("maka b = x , b = ",x)
            if f(x)*f(b) < 0:
                a = x
                print("maka a = x , a = ",x)
            if abs(a-b) < error:
                iteration = False
            else:
                i+=1
        else:
            print('tidak di temukan akar')
    print('x =', x)


regula_falsi(a,b)

Dapat kita ketahui pada program diatas dimana memberikan sebuah inisial terlebih dahulu dimana iterasi bervalue True, i = 0, dan iterasi maksimum yang digunakan 50.

DImana pada fungsi perulangan pada while iterasi dan i < max_iterasi, ketika kondisi telah terpenuhi maka akan melanjutkan ke kondisi berikutnya dimana pada kondisi ini f(a).f(b)< 0, ketika kondisinya telah tercapai maka melanjutkan ke proses perhitungan x = {(a|f(b)|+b|f(a)|) \over |f(a)| +|f(b|}. Ketika sudah melakukan proses pencarian x maka melanjutkan ke proses kondisi untuk melakukan swap (perubahan) dengan b =x ketika kondisi f(a).f(x)<0. atau kondisi f(x).f(b)<0 maka akan swap a = x

if f(a)*f(b) < 0:
            x = (a*abs(f(b)) + b*abs(f(a))) / (abs(f(a)) + abs(f(b)))
            if f(a)*f(x) < 0:
                b = x
                print("maka b = x , b = ",x)
            if f(x)*f(b) < 0:
                a = x
                print("maka a = x , a = ",x)

Lanjut melakukan pengecekan pada kondisi ketika nilai dari a-b < error maka iterasi akan bernilai False dan bila kondisi ini tidak terpenuhi maka melakukan proses penambahan i+=1

            if abs(a-b) < error:
                iteration = False
            else:
                i+=1

Maka ketika proses sudah berhasil terpenuhi maka iterasi akan False dan memprint hasil dari nilai akar yang di peroleh . Berikut Hasil yang diperoleh dari Hasil Program

Maka ketika proses sudah berhasil terpenuhi maka iterasi akan False dan memprint hasil dari nilai akar yang di peroleh . Berikut Hasil yang diperoleh dari Hasil Program

maka b = x , b =  2.25
maka b = x , b =  2.142857142857143
maka b = x , b =  2.076923076923077
maka b = x , b =  2.0400000000000005
maka b = x , b =  2.020408163265306
maka b = x , b =  2.010309278350516
maka b = x , b =  2.0051813471502595
maka b = x , b =  2.0025974025974027
maka b = x , b =  2.001300390117035
maka b = x , b =  2.0006506180871835
maka b = x , b =  2.000325414904003
maka b = x , b =  2.0001627339300247
maka b = x , b =  2.000081373586134
maka b = x , b =  2.000040688448549
maka b = x , b =  2.0000203446381697
maka b = x , b =  2.000010172422562
maka b = x , b =  2.00000508623715
maka b = x , b =  2.0000025431250426
maka b = x , b =  2.0000012715641384
maka b = x , b =  2.000000635782474
maka b = x , b =  2.0000003178913377
maka b = x , b =  2.000000158945694
maka b = x , b =  2.000000079472853
maka b = x , b =  2.000000039736428
maka b = x , b =  2.0000000198682146
maka b = x , b =  2.0000000099341078
maka b = x , b =  2.0000000049670534
maka b = x , b =  2.000000002483527
maka b = x , b =  2.000000001241763
maka b = x , b =  2.000000000620882
maka b = x , b =  2.0000000003104406
maka b = x , b =  2.0000000001552207
maka b = x , b =  2.00000000007761
maka b = x , b =  2.0000000000388054
maka b = x , b =  2.0000000000194023
maka b = x , b =  2.0000000000097016
maka b = x , b =  2.0000000000048503
maka b = x , b =  2.0000000000024256
maka b = x , b =  2.0000000000012124
maka b = x , b =  2.0000000000006066
maka b = x , b =  2.000000000000303
maka b = x , b =  2.000000000000152
maka b = x , b =  2.0000000000000755
maka b = x , b =  2.000000000000038
maka b = x , b =  2.0000000000000187
maka b = x , b =  2.0000000000000098
maka b = x , b =  2.0000000000000044
maka b = x , b =  2.0000000000000027
x = 2.000000000000001

Metode Newton Raphson

Metode pencarian akar persamaan dengan memanfaatkan kemiringan dan selisih tinggi dari dua titik batas range. Dua titik a dan b pada fungsi f(x) digunakan untuk mengestimasi posisi c dari akar interpolasi linier. Dikenal dengan metode False Position. Metode ini juga merupakan penyempurna dari metode bisection.

Algortima Pada Motode Newton Raphson

1.Definisikan fungsi $ f(x) , f'(x) $ yang akan dicari akarnya

2.Tentukan tebakan awal akar (katakanlah x_0) dan set $ n = 0 $

3.Tentukan toleransi $ \epsilon $ dan iterasi maksimum N

4.Hitung x_{n+1}=x_n -[f(x_n)/f'(x)_n]

5.Jika |x_{n+1} - x_n|<e , di mana ε adalah akurasi yang ditentukan, lalu lanjutkan ke Langkah 7, bila lanjut ke langkah 6

6.Set $ n = n+1 $ dan pergi ke langkah 4

7.Cetak nilai $ x_n$ yang merupakan nilai akar yang diperlukan

Perhitungan dalam Metode Newton Raphson

  1. Pada Langkah Awal Mendifinisikan sebuah fungsi f(x), dimana f(x) yang akan digunakan adalah : f(x) = x^2 - 5x +6 dan f'(x)= 2x-5

  2. Langkah kedua menentukan Nilai x_0 dan x_1, mengambil nilai batas awal (x_0)= 1 dan nilai batas bawahnya (x_1) = 2.4

  3. Langkah ketiga menentukan toleransi tingkat error dan iterasi maksimum (N), pada langkah ini tolerasi tingkat error yang akan digunakan =0,0001 dan iterasi maksimum yang digunakan =50

  4. Pada Langkah ini mengecek pada (x_0) = 1 dan (x_1) = 2.4. Apakah |x_1 - x_0|<e. Dan dapat kita ketahui bahwa > e maka lanjut ke proses berikutnya

  5. Menghitung f(x_1) dan f'(x_1), menghitung f(x_1) bisa kita gunakan pada fungsi f(x) dan pada f'(x_1) bisa kita gunakan pada fungsi f'(x) langkah pertama. Dimana f(x_1)=(2.4)^2-5(2.4)+6= -0.2400000000000002 dan f'(x_1)=2 x (2.4) -5 =-0.20000000000000018

  6. Mengecek dengan kondisi ketika |x_{n+1} - x_n|<e , di mana ε adalah akurasi yang ditentukan, lalu lanjutkan ke Langkah 7. Maka $$ X_2 = X_1 -{f(x_1) \over f'(x_1)} \\ X_2 = 2.4 -{-0.2400000000000002 \over -0.20000000000000018} \\ X_2 = 2.4 - 1.2 \\ X_2 = 1.2 $$ Melakukan Proses pengecekan ketika sudah memperoleh x_2= 1.2 maka apakah |x_2 - x_1|<e. Ketika kondisi tidak terpenuhi mengulang proses iterasi dengan melakukan penambahan n+1 jadi berpindah untuk mencari x_3. Bila proses kondisi terpenuhi dengan |x_{n+1} - x_n|<e maka lanjut ke proses langkah ke 7

  7. Cetak nilai $ x_n$ yang merupakan nilai akar yang diperlukan

Implementasi Algoritma Metode Newton Raphson Dengan Python

Pada Implementasi Algoritma Metode Newton Raphson ini, Pada Langkah pertama ini membuat fungsi f(x) dan fungsi f'(x) untuk bisa langsung memudahkan dalam perhitungan

def f(x):
    return x**2 - 5*x + 6

def f_turunan(x):
    return 2*x - 5

Pada Langkah Berikutnya membuat variabel kosong seperti variabel x0, serta error yang akan digunakan

error = 0.0001
xo = 0

Langkah Selanjutnya membuat fungsi , def Newton Raphson untuk bisa langsung mengkalkulasi hasil perhitungan pada fungsi yang digunakan diatas dan memberikan suatu iterasi (looping) ketika ada kondisi yang sudah terpenuhi

def newton_raphson(x0):
    iteration = True
    n = 0
    x_next = x0
    print("X_0 =",x_next)
    while iteration:
        x_curr = x_next
        x_next = x_curr - (f(x_curr)/f_turunan(x_curr))
        print("x_(",n+1,") = ",x_next)
        if abs(x_next - x_curr) < error:
            iteration = False
        else:
            n+=1

    print("x = ",x_next)

newton_raphson(xo)

Dapat kita ketahui pada program diatas dimana memberikan sebuah inisial terlebih dahulu dimana iterasi (n) = 0 ,dan inisial iterasi bervalue True, dimana n = 0 akan dimulai dari iterasi 0 untuk bisa melakukan sebuah perulangan (looping )

DImana pada fungsi perulangan pada while iteration, ketika kondisi telah terpenuhi maka akan melanjutkan ke perpindahan dan perhitungan setelah melakukan sebuah while iterasi

x_curr = x_next
x_next = x_curr - (f(x_curr)/f_turunan(x_curr))
print("x_(",n+1,") = ",x_next)

Lalu melakukan pengecekan apakah |x_{n+1} - x_n|<e bila benar maka iterasi = False dan memberikan nilai x sebagai nilai akar yang dicari, dan bila |x_{n+1} - x_n| tidak <e maka melanjutkan iterasi (looping) dengan n+=1

if abs(x_next - x_curr) < error:
        iteration = False
    else:
        n+=1

Maka ketika proses sudah berhasil terpenuhi maka iterasi akan False dan memprint hasil dari nilai akar yang di peroleh . Berikut Hasil yang diperoleh dari Hasil Program

X_0 = 0
x_( 1 ) =  1.2
x_( 2 ) =  1.7538461538461536
x_( 3 ) =  1.9593973037272008
x_( 4 ) =  1.9984752398055106
x_( 5 ) =  1.9999976821746035
x_( 6 ) =  1.9999999999946272
x =  1.9999999999946272

Metode Secant

Metode secant merupakan perbaikan dari metode regula-falsi dan newton raphson dimana kemiringan dua titik dinyatakan sacara diskrit, dengan mengambil bentuk garis lurus yang melalui satu titik. Metode Newton Raphson memerlukan perhitungan turunan fungsi f’(x). Tidak semua fungsi mudah dicari turunannya terutama fungsi yang bentuknya rumit. Turunan fungsi dapat dihilangkan dengan cara menggantinya dengan bentuk lain yang ekivalen Modifikasi metode Newton Raphson dinamakan metode Secant.

Pada Metode Newton-Raphson memerlukan syarat wajib yaitu fungsi f(x) harus memiliki turunan f'(x). Sehingga syarat wajib ini dianggap sulit karena tidak semua fungsi bisa dengan mudah mencari turunannya. Oleh karena itu muncul ide dari yaitu mencari persamaan yang ekivalen dengan rumus turunan fungsi. Ide ini lebih dikenal dengan nama Metode Secant. Ide dari metode ini yaitu menggunakan gradien garis yang melalui titik $ (x_0, f(x_0))$ dan $ (x_1, f(x_1))$. Perhatikan gambar dibawah ini.

Algortima Pada dengan Motode Secant

  1. Definisikan fungsi $ f(x) $ yang akan dicari akarnya

  2. Masukkan interval [a,b] dimana akar berada, atau bisa dengan menententukan nilai a dan b

  3. Tentukan toleransi $ \epsilon $ dan iterasi maksimum N

  4. Hitung $ f(a) $ dan $ f(b) $

  5. Menghitung x = a - [(b-a)/f(b)-f(a)]f(a)

  6. Jika |a-b|< \epsilon, \epsilon di mana $ \epsilon $ adalah akurasi yang ditentukan, lalu lanjutkan ke Langkah 8, bila tidak lanjut ke langkah 7

  7. Set $ a = b $ , $ b =x $ dan pergi ke langkah ke 4
  8. Cetak nilai $ x $ yang merupakan nilai akar yang dicari.

Perhitungan dalam Metode Secant

  1. Pada Langkah Awal Mendifinisikan sebuah fungsi f(x), dimana f(x) yang akan digunakan adalah : f(x) = x^2 - 5x +6

  2. Langkah kedua menentukan Nilai a dan b, mengambil nilai batas awal (a) = 1 dan nilai batas bawahnya (b) = 2.4 . Maka dapat kita ketahui interval [a,b]= [1,2.4]

  3. Langkah ketiga menentukan toleransi tingkat error dan iterasi maksimum (N), pada langkah ini tolerasi tingkat error yang akan digunakan =0,0001 dan iterasi maksimum yang digunakan =100

  4. Menghitung f(a) dan f(b), menghitung f(a) bisa kita gunakan pada fungsi f(x) pada langkah pertama.Dimana f(a)=1^2-5(1)+6=2 dan f(b)=(2.4)^2-5(2.4)+6=-0.2400000000000002

  5. Menghitung x = a - [(b-a)/f(b)-f(a)]f(a), maka $$ a = 1, b = 2.4,f(a) = 2, f(b)=-0.2400000000000002 \\ x = a - [(b-a)/f(b)-f(a)]f(a)\\ x = 1 - [(2.4 - 1)/-0.2400000000000002 - 2 ] 2 \\ x = 3.25 $$

  6. Pada langkah ini mengecek apakah |a-b|< e, e di mana ε adalah akurasi yang ditentukan, lalu lanjutkan ke Langkah 7, bila tidak lanjut ke langkah 6. Dapat kita ketahui bahwa |a-b|= |1-2.4|=-1.4 maka tidak bisa melanjutkan ke langkah 8 karena $|a-b|tidak < e $ maka lanjut ke langkah 7

  7. Meng -Set a = b , b =x dan pergi ke langkah ke 4. dimana $$ a = b,maka \quad a = 2.4, b = 3.25 \quad dan \quad lanjut \quad keLangkah \quad ke-4 $$

  8. Cetak nilai x yang merupakan nilai akar yang dicari.

Implementasi Algoritma Metode Secant Dengan Python

Pada Implementasi Algoritma Metode Secant ini, Pada Langkah pertama ini membuat fungsi f(x) untuk bisa langsung memudahkan dalam perhitungan

def f(x):
    return x**2 - 5*x + 6

Pada Langkah Berikutnya membuat variabel kosong seperti variabel a dan b, serta error yang akan digunakan

error = 0.0001
a = 1
b = 2.4

Langkah Selanjutnya membuat fungsi , def secant untuk bisa langsung mengkalkulasi hasil perhitungan pada fungsi yang digunakan diatas dan memberikan suatu iterasi (looping) ketika ada kondisi yang sudah terpenuhi

def secant(a,b):
    iteration = True
    while iteration:
        x = a - ((b-a) / (f(b) - f(a))) * f(a)
        print('x = ', x)
        if abs(a-b) < error:
            iteration = False
        else:
            a = b
            b = x

    print('x =', x)

secant(a,b)

Dapat kita ketahui pada program diatas dimana memberikan sebuah inisial terlebih dahulu dimana iterasi bervalue True

Dimana pada fungsi perulangan pada while iteration, ketika kondisi telah terpenuhi maka akan melanjutkan ke proses perhitungan x = a - [(b-a)/f(b)-f(a)]f(a) setelah melakukan sebuah while iterasi

while iteration:
        x = a - ((b-a) / (f(b) - f(a))) * f(a)
        print('x = ', x)
        if abs(a-b) < error:
            iteration = False
        else:
            a = b
            b = x

    print('x =', x)

Lanjut melakukan pengecekan pada kondisi ketika nilai dari a-b < error maka iterasi akan bernilai False dan bila kondisi ini tidak terpenuhi . Maka ketika proses sudah berhasil terpenuhi maka iterasi akan False dan memprint hasil dari nilai akar yang di peroleh . Dan ketika (a-b) tidak < error maka akan melakukan proses else : , dimana proses ini melakukan proses perpindahan (meng set a = b dan b = x)

if abs(a-b) < error:
    iteration = False
else:
    a = b
    print("set a = b maka a = ",b)
    b = x
    print("set b = x maka b = ",x)

Berikut merupakan hasil saat program dijalankan.

a =  1
b =  2.4
x =  2.25
x =  1.7142857142857166
x =  2.068965517241379
x =  2.016194331983806
x =  1.998779185106057
x =  2.0000200708123343
x =  2.0000000244733602
x =  1.999999999999509
x = 1.999999999999509